home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / umich / diskutil / certify.lzh / CERTIFY.C next >
Encoding:
C/C++ Source or Header  |  1985-11-20  |  6.9 KB  |  322 lines
  1. /*
  2.  * Disk tester.
  3.  *
  4.  * reads all the sectors on a disk and reports if they are good or bad.
  5.  *
  6.  * version 1.0  03/15/88
  7.  * by Dan Moore and Dave Small
  8.  * Copyright 1988 Antic Publishing Inc.
  9.  *
  10.  */
  11.  
  12. #include <osbind.h>
  13. #include <stdio.h>
  14.  
  15.     /* variables      */
  16. char    io_buff[5120];        /* ten sectors            */
  17. int    sectors;        /* sectors per track        */
  18. int    dblsided;        /* one or two            */
  19. int    drive;            /* A or B            */
  20. char    good_bad[10];        /* allow for 10 sector disks    */
  21.  
  22.     /* system defines */
  23. #define MAPTOP        (11)    /* top line of sector map    */
  24. #define LEGTOP        (MAPTOP + 10)    /* top of sector map legend */
  25. #define LEGCOL        (60)    /* left edge of legend        */
  26. #define SIDECOL        (15)    /* column to print side for map */
  27. #define SECTCOL        (55)    /* column for sector/sides info */
  28. #define MSGTOP        (24)    /* bottom line of screen for messages */
  29.  
  30. #define GOOD        (1)
  31. #define BAD        (0)
  32.  
  33. #define ESC        (0x1b)
  34.  
  35. /*
  36.  * redefine getchar for single character input using BIOS
  37.  * redefine putchar for single character output using BIOS
  38.  */
  39. #ifdef getchar
  40. # undef getchar
  41. #endif
  42. #define getchar() ((int)(Bconin(2) & 0xff))
  43.  
  44. #ifdef putchar
  45. # undef putchar
  46. #endif
  47. #define putchar(c) (Bconout((2), (c)))
  48.  
  49. /*
  50.  * misc. screen handling routines
  51.  */
  52. void
  53. clrscr()    /* nuke the screen */
  54. {
  55.     putchar(ESC);
  56.     putchar('E');    /* clear home command */
  57. }
  58.  
  59. void
  60. clreol()    /* nuke the line */
  61. {
  62.     putchar(ESC);
  63.     putchar('K');    /* clear to eol command */
  64. }
  65.  
  66. void
  67. movcur(r, c)
  68. int r,c;
  69. {
  70.     putchar(ESC);
  71.     putchar('Y');
  72.     putchar(32 + r);
  73.     putchar(32 + c);
  74. }
  75.  
  76. void
  77. curoff()
  78. {
  79.     putchar(ESC);
  80.     putchar('f');
  81. }
  82.  
  83. void
  84. curon()
  85. {
  86.     putchar(ESC);
  87.     putchar('e');
  88. }
  89.  
  90. /*
  91.  * disk map routines
  92.  */
  93. void
  94. printsector(track, sector, c)
  95. int track, sector;
  96. char c;
  97. {
  98.     movcur(MAPTOP + sector, track);
  99.     putchar(c);
  100. }
  101.  
  102. void
  103. trackprinter(start, end, sectors)
  104. int start, end, sectors;
  105. {
  106.     int track, sector;
  107.  
  108.     for (track = start; track <= end; track++)
  109.         for (sector = 0; sector < sectors; sector++)
  110.             printsector(track, sector, 'X');
  111. }
  112.  
  113. void
  114. showmap()
  115. {
  116.     /*
  117.      * draws a map of the sectors on the mac disk.  Tracks are columns
  118.      * sectors are rows.
  119.      */
  120.     register int i, j;
  121.  
  122.     curoff();
  123.  
  124.     movcur(MAPTOP-3, 37);
  125.     printf("\033pTRACK");    /* reverse on here */
  126.     movcur(MAPTOP-2, 0);
  127.     for (i = 0; i < 8; i++)        /* upper number line (tens) */
  128.         for (j = 0; j < 10; j++)
  129.             putchar(i + '0');
  130.     movcur(MAPTOP-1, 0);        /* actually one line up from map */
  131.     for (i = 0; i < 8; i++)        /* lower number line (ones) */
  132.         for (j = 0; j < 10; j++)
  133.             putchar(j + '0');
  134.     printf("\033q");    /* reverse off here */
  135.  
  136.     /* print the empty map */
  137.     trackprinter( 0, 79, sectors);
  138.  
  139.     printf("\033p");    /* reverse on */
  140.     movcur(LEGTOP, LEGCOL);
  141.     if (dblsided) {
  142.         printf("+ = both sides good");
  143.         movcur(LEGTOP + 1, LEGCOL);
  144.         printf("- = both sides bad ");
  145.         movcur(LEGTOP + 2, LEGCOL);
  146.         printf("1 = side one bad   ");
  147.         movcur(LEGTOP + 3, LEGCOL);
  148.         printf("2 = side two bad   ");
  149.     }
  150.     else {    /* one line lower than double sided legend */
  151.         printf("+ = good sector");
  152.         movcur(LEGTOP + 1, LEGCOL);
  153.         printf("- = bad sector ");
  154.     }
  155.     printf("\033q");    /* reverse off */
  156. }
  157.  
  158. void
  159. verifytracks()
  160. {
  161.     /*
  162.      * read all sectors (9 or 10) from the track.
  163.      */
  164.     register int  track, sector;
  165.     register char which;
  166.  
  167.     for (track = 0; track <= 79; track++) {
  168.         if (dblsided) {    /* which side now? */
  169.             movcur(MAPTOP-3, SIDECOL);
  170.             printf("\033pSIDE 1\033q");
  171.         }
  172.         /* buffer, filler, drive, sector, track, side, count */
  173.         if (Floprd(io_buff, 0L, drive, 1, track, 0, sectors) != 0) {
  174.             for (sector = 0; sector < sectors; sector++) {
  175.                 if (Floprd(io_buff, 0L, drive, sector + 1, track, 0, 1) != 0) {
  176.                     if (dblsided)
  177.                         which = '1';
  178.                     else 
  179.                         which = '-';
  180.                     good_bad[sector] = BAD;
  181.                 }
  182.                 else {
  183.                     which = '+';
  184.                     good_bad[sector] = GOOD;
  185.                 }
  186.                 printsector(track, sector, which);
  187.             }
  188.         }
  189.         else { /* all good */
  190.             for (sector = 0; sector < sectors; sector++) {
  191.                 good_bad[sector] = GOOD;
  192.                 printsector(track, sector, '+');
  193.             }
  194.         }
  195.  
  196.         if (dblsided) {
  197.             if (dblsided) {    /* which side now? */
  198.                 movcur(MAPTOP-3, SIDECOL);
  199.                 printf("\033pSIDE 2\033q");
  200.             }
  201.             /* buffer, filler, drive, sector, track, side, count */
  202.             if (Floprd(io_buff, 0L, drive, 1, track, 1, sectors) != 0) {
  203.                 for (sector = 0; sector < sectors; sector++) {
  204.                     if (Floprd(io_buff, 0L, drive, sector + 1, track, 0, 1) != 0) {
  205.                         if (good_bad[sector] == GOOD)
  206.                             which = '2';
  207.                         else 
  208.                             which = '-';
  209.                     }
  210.                     else 
  211.                         if (good_bad[sector] == GOOD)
  212.                             which = '+';
  213.                         else
  214.                             which = '1';
  215.                     printsector(track, sector, which);
  216.                 }
  217.             }
  218.             else { /* all good */
  219.                 for (sector = 0; sector < sectors; sector++) {
  220.                     if (good_bad[sector] == GOOD)
  221.                         printsector(track, sector, '+');
  222.                     else    /* side one was bad */
  223.                         printsector(track, sector, '1');
  224.                 }
  225.             }
  226.         }
  227.     }
  228. }
  229.  
  230. /*
  231.  * the main body
  232.  */
  233. void
  234. main()
  235. {
  236.     register int c;
  237.  
  238.     setbuf(stdout, 0L);    /* unbuffered i/o */
  239.     setbuf(stdin, 0L);
  240.  
  241.     for(;;) {
  242.         clrscr();
  243.         curoff();
  244.  
  245.         printf("\n\t\t\t\    \033pThe Amazing Disk Certifier\033q\n");
  246.         printf("\t\t\t            version 1.0\n");
  247.         printf("\t\t\t    by Dan Moore and Dave Small\n");
  248.         printf("\t\t\tCopyright 1988 Antic Publishing Inc.\n");
  249.         /*
  250.          * find out which drive to test
  251.          */
  252.         do {
  253.             movcur(10, 16);
  254.             printf(" \033pA\033q  -- test drive A");
  255.             movcur(11, 16);
  256.             printf(" \033pB\033q  -- test drive B");
  257.             movcur(12, 16);
  258.             printf(" \033pQ\033q  -- Quit");
  259.  
  260.             c = getchar() | 0x20;
  261.  
  262.             if (c == 'q') {
  263.                 clrscr();
  264.                 exit();        /* you can go home now */
  265.             }
  266.         }
  267.         while (!((c == 'a') || (c == 'b')));
  268.  
  269.         /* what did they choose */
  270.         drive = (c == 'b');
  271.  
  272.         /* nuke the old prompts now */
  273.         movcur(10, 16);
  274.         printf("                   ");
  275.         movcur(11, 16);
  276.         printf("                   ");
  277.         movcur(12, 16);
  278.         printf("           ");
  279.  
  280.         /*
  281.          * single or double sided
  282.          */
  283.         do {
  284.             movcur(10, 0);
  285.             printf("Is drive %c single or double sided (S or D)? ", drive + 'A');
  286.             clreol();
  287.             c = getchar() | 0x20;    /* forced lower case */
  288.         }
  289.         while (!((c == 's') || (c == 'd')));
  290.  
  291.         /* erase the prompt */
  292.         movcur(10, 0);
  293.         printf("                                           ");
  294.  
  295.         /* which was it? */
  296.         dblsided = (c == 'd');
  297.  
  298.         /* try reading sector 10 on track zero to see if this
  299.          * is a 9 or 10 sector disk.  Lets do this instead of
  300.          * reading the sectors/track entry in the boot block.
  301.          * this will allow us to work with non-GEM disks.
  302.          */
  303.         if (Floprd(io_buff, 0L, drive, 10, 0, 0, 1) != 0)
  304.             sectors = 9;
  305.         else
  306.             sectors = 10;
  307.  
  308.         /* go do it now */
  309.         showmap();
  310.  
  311.         /* tell how many sectors are being tested */
  312.         movcur(MAPTOP-3, SECTCOL);
  313.         printf("\033p%d SECTORS %d SIDED\033q", sectors, dblsided + 1);
  314.  
  315.         verifytracks();
  316.  
  317.         movcur(MSGTOP, 0);
  318.         printf("\033pTest completed.  Press RETURN to continue\033q");
  319.         while (getchar() != '\r');
  320.     }
  321. }
  322.